Music Genre Prediction: Molten Cores¶
__¶
Notes:¶
### Instrumentalness: vocals in a track
### Speechiness: detects the pressents of vocal words in a track
### Music genre: (10 different types)
- Electronic
- Classical
- Jazz
- anime
- Rock
- country
- Rap
- Blues
- Hip-Hop
- Alternative
Problems with table:¶
- [x] negative duration
- [x] missing tempos
- [x] rows 10000-10005 are nan values for every column
- [ ] negative loudness
__¶
All Libaries & Imports¶
In [1]:
import pandas as pd
import numpy as np
import plotly.express as px
import plotly.io as pio
import sklearn
import matplotlib.pyplot as plt
import seaborn as sns
import copy
import sklearn
import xgboost as xgb
from sklearn import tree
from sklearn import preprocessing
from sklearn import utils
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split # Import train_test_split function
from sklearn.metrics import roc_auc_score
from sklearn.metrics import f1_score, accuracy_score, confusion_matrix, classification_report
from sklearn.metrics import precision_score
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier # Import Decision Tree Classifier
from sklearn import metrics #Import scikit-learn metrics module for accuracy calculation
from xgboost import XGBClassifier
from IPython.display import Image
from subprocess import call
__¶
Functions¶
In [2]:
#This function returns the accuracy of tests
def getScore(y_test,y_hat):
labels = ['Electronic', 'Anime', 'Jazz', 'Alternative', 'Country', 'Rap', 'Blues', 'Rock', 'Classical', 'Hip-Hop']
print((np.sum((y_test - y_hat)**2))/len(y_test) )#mean squared error
print(classification_report(y_test, y_hat,target_names=[i+":" for i in labels]))
#This function replaces labels, such as Jazz, Rock, Rap, etc. with numbers. Each label now carries it's own number
def stringToInt(dataFrame,col):
test = {}
for i in dict(enumerate(dataFrame[col].unique())).items():#is a dictionary of the keys and corespodening number
#makes it so the keys and values of the dictionary switch
test[i[1]]=i[0]
print(test,'\n')
return dataFrame[col].map(test)
Fixing problems with the Dataset¶
In [3]:
#getting dataframe
df = pd.read_csv("music_genre.csv")
#dropping columns
badInfo = ["instance_id","obtained_date","artist_name","track_name"]
df.drop(columns=badInfo,axis=1,inplace=True)
#dropping null rows
df.dropna(inplace=True)
df.reset_index(drop=True, inplace=True) #Very good practice to reset how your rows are counted when you drop rows.
#fixing the problem with 'tempo' column
df["tempo"]=df["tempo"].replace("?",np.nan)
df["tempo"] = df["tempo"].astype("float")
df["tempo"]=df.groupby("music_genre")["tempo"].transform(lambda x: x.fillna(x.mean(skipna=True)))
df['tempo'] = np.around(df['tempo'],2)
#fixing the problem with 'duration' column
df["duration_ms"]=df["duration_ms"].replace(-1.0,np.nan)
df["duration_ms"]=df.groupby("music_genre")["duration_ms"].transform(lambda x: x.fillna(x.mean(skipna=True)))
df['duration_ms'] = np.around(df['duration_ms'],2)
#changing the values from string to int
df['key'] = stringToInt(df,'key')
df['mode'] = stringToInt(df,'mode')
df['music_genre_name'] = df['music_genre']
df['music_genre'] = stringToInt(df,'music_genre')
pio.templates.default = "plotly_dark"
dfxg = copy.deepcopy(df)
__¶
Spiting and scaling data¶
In [4]:
#Setting X to be all the input columns
X = df.loc[:,df.columns[:-2]]
#Setting y to be the desired column
y= df['music_genre']#what we want
#Splitting test and train ratio
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
#Scaling X variables
sc = preprocessing.StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform (X_test)
#for heat map
labels = ['Electronic', 'Anime', 'Jazz', 'Alternative', 'Country', 'Rap', 'Blues', 'Rock', 'Classical', 'Hip-Hop']
__¶
Plot¶
In [5]:
px.bar(df.sort_values(by=["music_genre_name"]), x='popularity', y='acousticness', color='music_genre_name')
# non danceable songs are of the highest acoustecness
# danceability and popularity are not correlated
# for each popularity, the least danceable songs tend to have the highest acousticness (at least until about 45 popularity)***
Out[5]:
In [6]:
df = df.sort_values(by=["key"])
px.bar(df, x='music_genre_name', y='tempo',color='key')
# tempo is highest for classical
# tempo is lowest for electronic
# clear pattern in tempo per genre
Out[6]:
In [7]:
#shows that we have an equal amount of each genre
df["music_genre_name"].hist(figsize = (10, 10))
Out[7]:
Out[7]:
In [8]:
px.scatter_3d(df, x = "acousticness", y = "tempo", z = "popularity", color = "music_genre_name", size="duration_ms",size_max=50)
Out[8]:
In [9]:
px.scatter(df.sort_values(by=["tempo"]), x = "loudness", y = "tempo", color = "music_genre_name", size="duration_ms",size_max=50,trendline="lowess")
Out[9]:
__¶
Logistic Regression¶
Logistic Regression is a Machine Learning classification algorithm that is used to predict the probability of a categorical dependent variable.
In logistic regression, the dependent variable is a binary variable that contains data coded as 1 (yes, success, etc.) or 0 (no, failure, etc.).
Types of LR¶
When we talk about Logistic Regression in general, we usually mean Binary logistic regression, although there are other types of Logistic Regression as well.
Logistic Regression can be divided into types based on the type of classification it does. With that in view, there are 3 types of Logistic Regression. Let’s talk about each of them:
- Binary Logistic Regression
- Multinomial Logistic Regression
- Ordinal Logistic Regression
In our case, we used Multinomial Logistic Regression
Multinomial Logistic Regression deals with cases when the target or independent variable has three or more possible values.
For example, the use of Chest X-ray images as features that give indication about one of the three possible outcomes (No disease, Viral Pneumonia, COVID-19). The multinomial Logistic Regression will use the features to classify the example into one of the three possible outcomes in this case. There can of course be more than three possible values of the target variable. in our case, there are 10.
In [10]:
#Building a model
model = LogisticRegression()
#Fitting our data
model.fit(X_train, y_train)
#Prediction of X_test
y_pred = model.predict(X_test)
#Finding out accurasy of train variables
X_train_acc = model.score(X_train, y_train)
print("The Accuracy for Training Set is {}".format(X_train_acc*100))
#Finding out accuracy of test variables
test_acc = model.score(X_test, y_test)
print("The Accuracy for Test Set is {}".format(test_acc*100))
#Printing classification report
getScore(y_test,y_pred)
In [11]:
#Confusion matrix
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='g', xticklabels=labels, yticklabels=labels)
Out[11]:
Out[11]:
__¶
Naive Bayes¶
About Naive Bayes :
Native Bayes is a machine learning model for classification that uses the Bayes Theorem( 
- P(H) is the probability of hypothesis H being true. This is known as the prior probability.
- P(E) is the probability of the evidence(regardless of the hypothesis).
- P(E|H) is the probability of the evidence given that hypothesis is true.
- P(H|E) is the probability of the hypothesis given that the evidence is there.
Good at predicting:
- Classical
Okay at predicting:
- Electronic
- Anime
- Hip-Hop
Bad at predicting:
- everything else
In [12]:
#Building a model
gnb = GaussianNB()
#Fitting data
y_hat = gnb.fit(X_train, y_train).predict(X_test)
#Confusion Matrix
sns.heatmap(confusion_matrix(y_test, y_hat), annot=True, fmt='g', xticklabels=labels, yticklabels=labels)
Out[12]:
Out[12]:
In [13]:
# Accuracy of the test
getScore(y_test,y_hat)
__¶
Classification Trees¶
About Classification Trees:
Decision Trees (DTs) are a non-parametric supervised learning method used for classification and regression. The goal is to create a model that predicts the value of a target variable by learning simple decision rules inferred from the data features. A tree can be seen as a piecewise constant approximation.
Pros
- Simple to understand and to interpret. Trees can be visualized.
- Requires little data preparation.
- Able to handle both numerical and categorical data.
- Possible to validate a model using statistical tests.
Cons
- Decision-tree learners can create over-complex trees that do not generalize the data well.
- Decision trees can be unstable because small var iations in the data might result in a completely different tree being generated
- Predictions of decision trees are neither smooth nor continuous, but piecewise constant approximations as seen in the above figure.
- Decision tree learners create biased trees if some classes dominate.
In [14]:
#Building a model
clf = DecisionTreeClassifier(max_depth = 2, random_state = 0)
#Fitting in our data
clf = clf.fit(X_train,y_train)
#Predicting X_test
y_pred = clf.predict(X_test)
#Accuracy of the test
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
fig, axe = plt.subplots(figsize=(36,30))
tree.plot_tree(clf, ax = axe, fontsize=15)
Out[14]:
Out[14]:
In [15]:
param_grid = {'max_depth': np.arange(3, 6)}
tree = GridSearchCV(DecisionTreeClassifier(), param_grid)
tree.fit(X_train, y_train)
tree_pred = tree.predict_proba(X_test)[:, 1]
print ("DecisionTree: Area under the ROC curve = {}".format(tree))
__¶
Random Forest¶
In [16]:
print(X_train.shape) # Prints out the shape of the variable.
print(X_test.shape) # Prints out the shape of the variable.
print(y_train.shape) # Prints out the shape of the variable.
print(y_test.shape) # Prints out the shape of the variable.
In [17]:
tst = RandomForestClassifier(max_depth=2, random_state=0) # RandomForestRegressor is added.
y_pred1 = tst.fit(X_train, y_train).predict(X_test) # Fits the model and predicts
print("\n------------------------------------------------------\n")
getScore(y_test, y_pred1)
print("\n------------------------------------------------------\n")
print("Accuracy:", accuracy_score(y_test, y_pred1))
print("\n------------------------------------------------------\n")
__¶
Xgboost:¶
XgBoost stands for Extreme Gradient Boosting
In [18]:
model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
y_pred = model.fit(X_train, y_train).predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Overall Accuracy: ", accuracy)
total_squared_error = (np.sum((y_test - y_pred)**2))
mean_squared_error = total_squared_error/len(y_test)
print(mean_squared_error)
#confusion matrix
labels = ['Electronic', 'Anime', 'Jazz', 'Alternative', 'Country', 'Rap', 'Blues', 'Rock', 'Classical', 'Hip-Hop']
# sns.heatmap(confusion_matrix(y_test.values.argmax(axis=1), y_pred.argmax(axis=1)), annot=True, fmt='g', xticklabels=labels, yticklabels=labels)
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='g', xticklabels=labels, yticklabels=labels)
Out[18]:
Out[18]:
